package com.bd.scm.module.oauth2;

import com.google.gson.internal.LinkedTreeMap;
import java.io.InputStreamReader;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import javax.servlet.http.HttpServletRequest;

public class ParaUtil {

    public static String appId = "CbtEGup0dHNO8W0B";
    public static String appKey = "Wzsuh1BB1dT8vuxWYnO62gwoVQBCjhmZ";

    public static HashMap<String, Object> process(HttpServletRequest request) {
        HashMap<String, Object> data = null;
        HashMap<String, Object> res = new HashMap<>();
        try {
            InputStreamReader isr = new InputStreamReader(request.getInputStream(), "utf-8");
            char[] buffer = new char[1024];
            String str = "";
            int len = 0;
            while ((len = isr.read(buffer, 0, 1024)) != -1) {
                str += String.valueOf(Arrays.copyOfRange(buffer, 0, len));
            }
            isr.close();
            System.out.println(str);
            data = Json.deserialize(str, HashMap.class);
            res.put("requestId", data.get("requestId"));
            // 校验来源合法性，不重要
            if (!appId.equals(data.get("appId")) || !appKey.equals(data.get("appKey"))) {
                throw new Exception("认证信息错误");
            }
            res.put("returnFlag", "true");
            res.put("returnCode", "0");
            res.put("returnMessage", "");
            String actionType = data.get("actionType").toString();
            Method method = ParaUtil.class.getDeclaredMethod("do" + actionType, HashMap.class, HashMap.class);
            method.invoke(null, new Object[]{data, res});
        } catch (Exception ex) {
            ex.printStackTrace();
            res.put("returnFlag", "false");
            res.put("returnCode", "1");
            res.put("returnMessage", ex.getMessage());
        }
        return res;
    }

    public static void doAdd(HashMap<String, Object> data, HashMap<String, Object> res) {
        ArrayList<LinkedTreeMap> list = (ArrayList<LinkedTreeMap>) data.get("accountList");
        LinkedTreeMap account = list.get(0); // 实际处理时请循环处理整个数组
        // 传来的字段很多，以OA为原型设计的，我们一般只需要以下信息：
        // uid 派拉的用户账号，可存可不存，此账号在派拉中惟一
        // accountId 应用的用户账号，若冲突则改为更新，不要让请求失败，否则派拉会出问题
        // name 姓名
        // cardNo 饭卡号 不重要
        // email 邮箱，测试库是空的，有问题
        // phone 手机
        // code 工号
        // tel 分机号 不重要
        // accountPassword 明文密码，忽略即可
        // 根据上面的信息建立账号即可，但初始无权限或组织，由管理员手工在各系统中维护
        HashMap<String, Object> ret = new HashMap<>();
        ret.put("accountId", account.get("accountId")); // 原样返回
        ret.put("accountCode", ""); // accountCode请始终保持空白
        ArrayList<HashMap> al = new ArrayList<>();
        al.add(ret);
        res.put("accountList", al); // 请与请求的数组长度保持一致，返回给派拉
    }

    public static void doDisable(HashMap<String, Object> data, HashMap<String, Object> res) {
        // 建议什么也不做
    }

    public static void doEnable(HashMap<String, Object> data, HashMap<String, Object> res) {
        // 建议什么也不做
    }

    public static void doDelete(HashMap<String, Object> data, HashMap<String, Object> res) {
        // 循环并逻辑删除账号，停用也可
    }

    public static void doModify(HashMap<String, Object> data, HashMap<String, Object> res) {
        // 处理方法与Add几乎一样，除了accountId必须是已存在的账号之外
        // 为防止出错，accountId如果找不到，就当新增处理，不要向派拉返回失败
        // 修改不需要返回额外的账号数组信息
    }

    public static void doModifyPassword(HashMap<String, Object> data, HashMap<String, Object> res) {
        // 建议什么也不做
    }

    public static void doTestConnection(HashMap<String, Object> data, HashMap<String, Object> res) {
        // 什么也不做
    }

    public static void doReclaimAccount(HashMap<String, Object> data, HashMap<String, Object> res) {
        // 回收账号，分为精准、按时间段和全部回收，建议实现全部回收即可，按时间段的返回空白列表，精确回收的原样返回
        ArrayList<LinkedTreeMap> accountList = (ArrayList<LinkedTreeMap>) data.get("accountList");
        // 这里我怀疑这个数组长度永远只会是1，因此不考虑1条以上的情况
        LinkedTreeMap type = accountList.get(0);
        String reclaimAccountType = type.get("reclaimAccountType").toString();
        // 0-全部回收 1-精确回收 2-部分回收
        if ("1".equals(reclaimAccountType)) {
            String accountId = type.get("accountId").toString();
            HashMap<String, Object> ret = new HashMap<>();
            ret.put("accountId", accountId); // 原样返回
            ret.put("accountCode", ""); // accountCode请始终保持空白
            ret.put("appCustomAttrs", new Object[]{}); // 无自定义属性
            ArrayList<HashMap> al = new ArrayList<>();
            al.add(ret);
            res.put("accountList", al);
        } else if ("2".equals(reclaimAccountType)) {
            res.put("accountList", new Object[]{}); // 返回空数组
        } else {
            // 全部回收时，请注意返回分页信息
            int currentPage = Integer.parseInt(data.get("currentPage").toString());
            int totalAccount = 1;
            int totalPage = 1; // 多于1页的情况下，派拉应该会自动循环调用
            res.put("currentPage", String.valueOf(currentPage));
            res.put("totalAccount", String.valueOf(totalAccount));
            res.put("totalPage", String.valueOf(totalPage));
            ArrayList<HashMap> al = new ArrayList<>();
            if (currentPage == 1) {
                HashMap<String, Object> ret = new HashMap<>();
                ret.put("accountId", "01222"); // 请配置回收策略
                ret.put("accountCode", ""); // accountCode请始终保持空白
                ret.put("appCustomAttrs", new Object[]{}); // 无自定义属性
                al.add(ret);
            }
            res.put("accountList", al);
        }
    }

    public static void doParticularChanges(HashMap<String, Object> data, HashMap<String, Object> res) {
        // 什么也不做
    }
}
